home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 4 / FM Towns Free Software Collection 4 - Disc 1.iso / t_os / bricon / source / consol.c < prev    next >
Text File  |  1991-10-18  |  16KB  |  739 lines
  1. #include    <stdio.h>
  2. #include    <stdlib.h>
  3. #include    <jctype.h>
  4.  
  5. #define TRUE    1
  6. #define FALSE   0
  7. #define ERR     (-1)
  8.  
  9. #define UCHAR   unsigned char
  10. #define SHORT   short int
  11. #define    UNSIG    unsigned int
  12.  
  13. #define    CVRAM    0xC800
  14. #define    KVRAM    0xCA00
  15.  
  16. #define    SCR_X    80
  17. #define MAX_X   80
  18. #define MAX_Y   25
  19.  
  20. #define DMYKAN  0xFE
  21. #define CRCHR   0x1F
  22. #define TABCHR  0x09
  23. #define    NULCHR    0x20
  24. #define TAB     8
  25. #define CONTRL  FALSE
  26. #define    DEFCOL    COLOR
  27. #define    ESPSIZ    32
  28.  
  29. extern SHORT    OLD_X;
  30. extern SHORT    CUR_X,CUR_Y;
  31. extern SHORT    CUR_TYPE;
  32. extern SHORT    CUR_OFF2,CUR_SIZE2;
  33. extern UCHAR    CUR_DSP_FLG;
  34. extern UCHAR    Con_mode;
  35. extern SHORT    SCR_Y;
  36. extern SHORT    COLOR,BAKCOL;
  37.  
  38. static UCHAR    TABMAP[MAX_X/8];
  39. static UCHAR    BITMAP[8]={ 0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01 };
  40.  
  41. static SHORT    TABFLG=FALSE;
  42. static SHORT    ODR_FLG=TRUE;
  43. static SHORT    KANMOD=TRUE;
  44. static UCHAR    BAKCH1=0;
  45. static UCHAR    KANCOD=0;
  46. static SHORT    EXTFLG=FALSE;
  47. static void    (*EXTPRO)();
  48. static SHORT    ESCCNT=0;
  49. static char    ESCPRM[ESPSIZ];
  50. static SHORT    BAK_X,BAK_Y;
  51.  
  52. void    SetDC2_s();
  53. void    SetDC3_s();
  54. void    SCurPs_s();
  55. void    AnsiCom();
  56. void    SCurPs();
  57. void    SVidAt();
  58. void    CurAtt();
  59. void    SetDC2();
  60. void    SetDC3();
  61. void    EscCom();
  62. void    Beep();
  63.  
  64. static void    NextChr(sub)
  65. void     (*sub)();
  66. {
  67.     EXTFLG = TRUE;
  68.     EXTPRO = sub;
  69. }
  70. static void    Scrool()
  71. {
  72.     vramcpy(0,(MAX_X * 2),(MAX_X * 2) * (SCR_Y - 1));
  73.     colset((MAX_X * 2) * (SCR_Y - 1),COLOR,(MAX_X * 2));
  74. }
  75. static void    Put_Ank(ch)
  76. int    ch;
  77. {
  78.     register union {
  79.     UCHAR far    *p;
  80.     unsigned short  s[2];
  81.     } ptr;
  82.  
  83.     ptr.s[0] = (CUR_X * 2 + (MAX_X * 2) * CUR_Y);
  84.     ptr.s[1] = CVRAM;
  85.     *(ptr.p) = ch;
  86.     *(ptr.p+1) = COLOR;
  87.  
  88.     if ( CUR_X > 0 && (*(ptr.p-1) & 0x40) != 0 )
  89.     *(ptr.p-1) &= 0xBF;
  90.  
  91.     if ( ++CUR_X >= SCR_X ) {
  92.         if ( ODR_FLG != FALSE ) {
  93.         CUR_X = 0;
  94.         if ( ++CUR_Y >= SCR_Y ) {
  95.                 CUR_Y = SCR_Y - 1;
  96.                 Scrool();
  97.             }
  98.     } else
  99.         CUR_X = SCR_X - 1;
  100.     }
  101. }
  102. static void    Put_Kan(ch)
  103. int    ch;
  104. {
  105.     register union {
  106.     UCHAR far    *p;
  107.     unsigned short  s[2];
  108.     } ptr;
  109.  
  110.     if ( CUR_X >= (SCR_X - 1) ) {
  111.     Put_Ank(DMYKAN);
  112.     Put_Ank(DMYKAN);
  113.     return;
  114. /*****************************************
  115.         if ( ODR_FLG != FALSE ) {
  116.         CUR_X = 0;
  117.         if ( ++CUR_Y >= SCR_Y ) {
  118.                 CUR_Y = SCR_Y - 1;
  119.                 Scrool();
  120.             }
  121.     } else
  122.         CUR_X = SCR_X - 2;
  123. *******************************************/
  124.     }
  125.  
  126.     ch = sjisto(ch);
  127.  
  128.     ptr.s[0] = (CUR_X * 2 + (MAX_X * 2) * CUR_Y);
  129.     ptr.s[1] = CVRAM;
  130.  
  131.     *ptr.p = DMYKAN;
  132.     *(ptr.p+1) = 0x40|COLOR;
  133.     *(ptr.p+2) = DMYKAN;
  134.     *(ptr.p+3) = COLOR;
  135.  
  136.     if ( CUR_X > 0 && (*(ptr.p-1) & 0x40) != 0 )
  137.     *(ptr.p-1) &= 0xBF;
  138.  
  139.     ptr.s[1] = KVRAM;
  140.     *(ptr.p) = ch >> 8;
  141.     *(ptr.p+1) = ch;
  142.     *(ptr.p+2) = 0;
  143.     *(ptr.p+3) = 0;
  144.  
  145.     if ( (CUR_X += 2) >= SCR_X ) {
  146.         if ( ODR_FLG != FALSE ) {
  147.         CUR_X = 0;
  148.         if ( ++CUR_Y >= SCR_Y ) {
  149.                 CUR_Y = SCR_Y - 1;
  150.                 Scrool();
  151.             }
  152.     } else
  153.         CUR_X = SCR_X - 1;
  154.     }
  155. }
  156. static void    PutBS()
  157. {
  158.     if ( --CUR_X < 0 ) {
  159.         CUR_X = SCR_X - 1;
  160.         if ( --CUR_Y < 0 )
  161.             CUR_Y = 0;
  162.     }
  163. }
  164. static void    PutTAB()
  165. {
  166.     int     i;
  167.  
  168.     if ( TABFLG == FALSE || (Con_mode & 0x02) == 0 ) {
  169.         Put_Ank(' ');
  170.         return;
  171.     }
  172.  
  173.     for ( i = CUR_X ; i < SCR_X ; i++ ) {
  174.         Put_Ank(' ');
  175.         if ( (TABMAP[CUR_X / 8] & BITMAP[CUR_X % 8]) != 0 )
  176.             break;
  177.     }
  178. }
  179. static void    PutLF()
  180. {
  181.     if ( ++CUR_Y >= SCR_Y ) {
  182.     CUR_Y = (SCR_Y - 1);
  183.     Scrool();
  184.     }
  185.     if ( (Con_mode & 0x01) != 0 )
  186.     CUR_X = 0;
  187. }
  188. static void    PutHOME()
  189. {
  190.     CUR_X = CUR_Y = 0;
  191. }
  192. static void    PutCLS()
  193. {
  194.     colset(0,COLOR,(MAX_X * 2) * SCR_Y);
  195.     CUR_X = CUR_Y = 0;
  196. }
  197. static void    PutCR()
  198. {
  199.     CUR_X = 0;
  200.     if ( (Con_mode & 0x01) != 0 )
  201.     PutLF();
  202. }
  203. static void    CurRit()
  204. {
  205.     if ( ++CUR_X >= SCR_X )
  206.         CUR_X = 0;
  207. }
  208. static void    CurLft()
  209. {
  210.     if ( --CUR_X < 0 )
  211.         CUR_X = SCR_X - 1;
  212. }
  213. static void    CurUp()
  214. {
  215.     if ( --CUR_Y < 0 )
  216.     CUR_Y = SCR_Y - 1;
  217. }
  218. static void    CurDwn()
  219. {
  220.     if ( ++CUR_Y >= SCR_Y )
  221.         CUR_Y = 0;
  222. }
  223. static void    SVidAt(ch)
  224. int     ch;
  225. {
  226.     COLOR = ch & 0x3F;
  227. }
  228. static void    SetDC2_s(ch)
  229. int     ch;
  230. {
  231.     CUR_X = BAKCH1;
  232.     CUR_Y = ch;
  233.     if ( CUR_X < 0 ) CUR_X = 0;
  234.     if ( CUR_X >= SCR_X ) CUR_X = SCR_X - 1;
  235.     if ( CUR_Y < 0 ) CUR_Y = 0;
  236.     if ( CUR_Y >= SCR_Y ) CUR_Y = SCR_Y - 1;
  237. }
  238. static void    SetDC2(ch)
  239. int     ch;
  240. {
  241.     BAKCH1 = ch;
  242.     NextChr(SetDC2_s);
  243. }
  244. static void    SetDC3_s(ch)
  245. int     ch;
  246. {
  247.     while ( BAKCH1-- > 0 )
  248.         Put_Ank(ch);
  249. }
  250. static void    SetDC3(ch)
  251. int     ch;
  252. {
  253.     BAKCH1 = ch;
  254.     NextChr(SetDC3_s);
  255. }
  256. static void    EraLin()
  257. {
  258.     colset((CUR_X * 2) + (MAX_X * 2) * CUR_Y,COLOR,(MAX_X - CUR_X) * 2);
  259. }
  260. static void    EraScr()
  261. {
  262.     colset((CUR_X * 2) + (MAX_X * 2) * CUR_Y,COLOR,
  263.        (MAX_X * 2) * SCR_Y - ((CUR_X * 2) + (MAX_X * 2) * CUR_Y));
  264. }
  265. static void    InsLin()
  266. {
  267.     int     i;
  268.     UNSIG   p;
  269.  
  270.     p = (MAX_X * 2) * (SCR_Y - 1);
  271.     for ( i = SCR_Y - 1 ; i > CUR_Y ; i-- ) {
  272.         vramcpy(p,p-(MAX_X * 2),(MAX_X * 2));
  273.         p -= (MAX_X * 2);
  274.     }
  275.     colset((MAX_X * 2) * CUR_Y,COLOR,MAX_X * 2);
  276. }
  277. static void    DelLin()
  278. {
  279.     int     i;
  280.     UNSIG   p;
  281.  
  282.     p = (MAX_X * 2) * CUR_Y;
  283.     for ( i = CUR_Y ; i < (SCR_Y - 1) ; i ++ ) {
  284.         vramcpy(p,p+(MAX_X * 2),(MAX_X * 2));
  285.         p += (MAX_X * 2);
  286.     }
  287.     colset((MAX_X * 2) * (SCR_Y - 1),COLOR,MAX_X * 2);
  288. }
  289. static void    SCurPs_s(ch)
  290. int     ch;
  291. {
  292.     CUR_Y = BAKCH1 - ' ';
  293.     CUR_X = ch - ' ';
  294.     if ( CUR_X < 0 ) CUR_X = 0;
  295.     if ( CUR_X >= SCR_X ) CUR_X = SCR_X - 1;
  296.     if ( CUR_Y < 0 ) CUR_Y = 0;
  297.     if ( CUR_Y >= SCR_Y ) CUR_Y = SCR_Y - 1;
  298. }
  299. static void    SCurPs(ch)
  300. int     ch;
  301. {
  302.     BAKCH1 = ch;
  303.     NextChr(SCurPs_s);
  304. }
  305. static void    CurAtt_s(ch)
  306. {
  307.     CUR_TYPE = BAKCH1 & 0x70;
  308.     CUR_OFF2 = BAKCH1 & 0x1F;
  309.     CUR_SIZE2 = (ch & 0x1F) - CUR_OFF2;
  310.     if ( CUR_OFF2 < 0 || CUR_OFF2 > 15 )
  311.     CUR_OFF2 = 15;
  312.     if ( CUR_SIZE2 < 0 || (CUR_SIZE2 + CUR_OFF2) > 16 )
  313.     CUR_SIZE2 = 16 - CUR_OFF2;
  314.     CUR_DSP_FLG = ((BAKCH1 & 0x60) == 0x20 ? 1:0);
  315.     OLD_X = 0xFFFF;
  316. }
  317. static void    CurAtt(ch)
  318. int    ch;
  319. {
  320.     BAKCH1 = ch;
  321.     NextChr(CurAtt_s);
  322. }
  323. static void     KanjiIn(ch)
  324. int     ch;
  325. {
  326.     if ( ch != 'B' && ch != '@' )
  327.         Put_Ank(ch);
  328. }
  329. static void     KanjiOut(ch)
  330. int     ch;
  331. {
  332.     if ( ch != 'B' && ch != 'J' )
  333.         Put_Ank(ch);
  334. }
  335. static void    CurPos()
  336. {
  337.     ESCPRM[0] = CUR_Y + ' ';
  338.     ESCPRM[1] = CUR_X + ' ';
  339.     ESCPRM[2] = 0x0D;
  340.     KeyBufIns(ESCPRM,3);
  341. }
  342. static void     TabSet()
  343. {
  344.     TABMAP[CUR_X / 8] |= BITMAP[CUR_X % 8];
  345.     TABFLG = TRUE;
  346. }
  347. static void     TabReSet()
  348. {
  349.     TABMAP[CUR_X / 8] &= (~BITMAP[CUR_X % 8]);
  350. }
  351. static void    TabClr()
  352. {
  353.     memset(TABMAP,0,MAX_X/8);
  354.     TABFLG = FALSE;
  355. }
  356.  
  357. /*****************************************************************
  358.         ANSIエスケ－プシ－ケンス制御関数群
  359. ******************************************************************/
  360.  
  361. static void    AnsiA()
  362. {
  363.     if ( ESCPRM[0] == 0 ) ESCPRM[0] = 1;
  364.     if ( (CUR_Y -= ESCPRM[0]) < 0 )
  365.         CUR_Y = 0;
  366. }
  367. static void    AnsiB()
  368. {
  369.     if ( ESCPRM[0] == 0 ) ESCPRM[0] = 1;
  370.     if ( (CUR_Y += ESCPRM[0]) >= SCR_Y )
  371.         CUR_Y = SCR_Y - 1;
  372. }
  373. static void    AnsiC()
  374. {
  375.     if ( ESCPRM[0] == 0 ) ESCPRM[0] = 1;
  376.     if ( (CUR_X += ESCPRM[0]) >= SCR_X )
  377.         CUR_X = SCR_X - 1;
  378. }
  379. static void    AnsiD()
  380. {
  381.     if ( ESCPRM[0] == 0 ) ESCPRM[0] = 1;
  382.     if ( (CUR_X -= ESCPRM[0]) < 0 )
  383.         CUR_X = 0;
  384. }
  385. static void    AnsiG()
  386. {
  387.     if ( ESCPRM[0] > 0 ) ESCPRM[0]--;
  388.     CUR_X = ESCPRM[0];
  389.     if ( CUR_X < 0 )      CUR_X = 0;
  390.     if ( CUR_X >= SCR_X ) CUR_X = SCR_X - 1;
  391. }
  392. static void    AnsiH()
  393. {
  394.     if ( ESCPRM[0] > 0 ) ESCPRM[0]--;
  395.     if ( ESCPRM[1] > 0 ) ESCPRM[1]--;
  396.     CUR_Y = ESCPRM[0];
  397.     CUR_X = ESCPRM[1];
  398.     if ( CUR_X < 0 ) CUR_X = 0;
  399.     if ( CUR_X >= SCR_X ) CUR_X = SCR_X - 1;
  400.     if ( CUR_Y < 0 ) CUR_Y = 0;
  401.     if ( CUR_Y >= SCR_Y ) CUR_Y = SCR_Y - 1;
  402. }
  403. static void    AnsiJ()
  404. {
  405.     switch(ESCPRM[0]) {
  406.         case 0: EraScr(); break;
  407.         case 1: colset(0,COLOR,(CUR_X * 2) + (MAX_X * 2) * CUR_Y); break;
  408.         case 2: PutCLS(); break;
  409.     }
  410. }
  411. static void    AnsiK()
  412. {
  413.     switch(ESCPRM[0]) {
  414.         case 0: EraLin(); break;
  415.         case 1:
  416.             if ( CUR_X > 0 )
  417.         colset((MAX_X * 2) * CUR_Y,COLOR,CUR_X * 2);
  418.             break;
  419.         case 2: colset((MAX_X * 2) * CUR_Y,COLOR,MAX_X * 2); break;
  420.     }
  421. }
  422. static void    AnsiL()
  423. {
  424.     do {
  425.         InsLin();
  426.     } while ( --ESCPRM[0] > 0 );
  427.     CUR_X = 0;
  428. }
  429. static void    AnsiM()
  430. {
  431.     do {
  432.         DelLin();
  433.     } while ( --ESCPRM[0] > 0 );
  434.     CUR_X = 0;
  435. }
  436. static void     AnsiP()
  437. {
  438.     int     n;
  439.  
  440.     if ( (n = ESCPRM[0]) <= 0 ) n = 1;
  441.     if ( (n + CUR_X) > SCR_X ) n = SCR_X - CUR_X;
  442.  
  443.     vramrcpy((CUR_X + SCR_X * CUR_Y) * 2,
  444.          (CUR_X + n + SCR_X * CUR_Y) * 2,
  445.          (SCR_X - CUR_X - n) * 2);
  446.     colset((SCR_X - n + SCR_X * CUR_Y) * 2,COLOR,n * 2);
  447. }
  448. static void    Ansid()
  449. {
  450.     if ( ESCPRM[0] > 0 ) ESCPRM[0]--;
  451.     CUR_Y = ESCPRM[0];
  452.     if ( CUR_Y < 0 )      CUR_Y = 0;
  453.     if ( CUR_Y >= SCR_Y ) CUR_Y = SCR_Y - 1;
  454. }
  455. static void     Ansig()
  456. {
  457.     switch(ESCPRM[0]) {
  458.     case 2:
  459.     TabClr();
  460.         break;
  461.     }
  462. }
  463. static void    Ansis()
  464. {
  465.     BAK_X = CUR_X;
  466.     BAK_Y = CUR_Y;
  467. }
  468. static void    Ansiu()
  469. {
  470.     CUR_X = BAK_X;
  471.     CUR_Y = BAK_Y;
  472. }
  473. static void    Ansiv()
  474. {
  475.     CUR_DSP_FLG = ESCPRM[0];
  476.     OLD_X = 0xFFFF;
  477. }
  478. static void    Ansim()
  479. {
  480.     int     c;
  481.     int     i,n;
  482.     static char ansiatt[]={ 0x00,0x20,0x00,0x00,0x00,0x10,0x00,0x08,0x00 };
  483.     static char ansicol[]={ 0,2,4,6,1,3,5,7 };
  484.  
  485.     for ( n = 0,c = 0x07 ; n < ESCCNT ; n++ ) {
  486.         if ( (i = ESCPRM[n]) > 0 && i <= 8 ) {
  487.             c |= ansiatt[i];
  488.         } else if ( i == 0 ) {
  489.         c &= 0x07;
  490.     } else if ( i >= 30 && i <= 38 ) {
  491.             c &= 0xF8;
  492.             c |= ansicol[i-30];
  493.         } else if ( i >= 40 && i <= 47 ) {
  494.             BAKCOL = ansicol[i-40];        /* 現在未サポ－ト */
  495.         }
  496.     }
  497.     COLOR = c;
  498. }
  499. static void    Ansin()
  500. {
  501.     int       i,n;
  502.  
  503.     if ( ESCPRM[0] != 6 )
  504.     return;
  505.  
  506.     n = 0;
  507.     ESCPRM[n++] = '\033';
  508.     ESCPRM[n++] = '[';
  509.  
  510.     if ( (i = CUR_Y + 1) >= 10 )
  511.     ESCPRM[n++] = '0' + i / 10;
  512.     ESCPRM[n++] = '0' + i % 10;
  513.  
  514.     ESCPRM[n++] = ';';
  515.  
  516.     if ( (i = CUR_X + 1) >= 10 )
  517.     ESCPRM[n++] = '0' + i / 10;
  518.     ESCPRM[n++] = '0' + i % 10;
  519.  
  520.     ESCPRM[n++] = 'R';
  521.  
  522.     KeyBufIns(ESCPRM,n);
  523. }
  524. static void    AnsKeyAs()
  525. {
  526.     int        ch,i;
  527.  
  528.     i = 0;
  529.     if ( (ch = (UCHAR)ESCPRM[i++]) == 0 )
  530.     ch = 0x8000 | (UCHAR)ESCPRM[i++];
  531.     if ( (ESCCNT - i) < 1 )
  532.     return;
  533.     AsinKey(ch,ESCCNT - i,&ESCPRM[i]);        /* Compile to BIOS.ASM */
  534. }
  535. static void     AnsiIc()
  536. {
  537.     int     i,n;
  538.     char    *p,*s;
  539.  
  540.     if ( (n = ESCPRM[0]) <= 0 ) n = 1;
  541.     if ( (n + CUR_X) > SCR_X ) n = SCR_X - CUR_X;
  542.  
  543.     vramrcpy((SCR_X - 1 + SCR_X * CUR_Y) * 2,
  544.          (SCR_X - 1 - n + SCR_X * CUR_Y) * 2,
  545.          (SCR_X - CUR_X - n) * 2);
  546.     colset((CUR_X + SCR_X * CUR_Y) * 2,COLOR,n * 2);
  547. }
  548. static void    AnsStr(ch)
  549. int    ch;
  550. {
  551.     if ( ch == '\"' )
  552.     NextChr(AnsiCom);
  553.     else {
  554.     if ( ESCCNT < ESPSIZ )
  555.         ESCPRM[ESCCNT++] = ch;
  556.     NextChr(AnsStr);
  557.     }
  558. }
  559. static void    AnsiCom(ch)
  560. int     ch;
  561. {
  562.     if ( ch == ';' && ESCCNT < ESPSIZ )
  563.         ESCCNT++;
  564.  
  565.     else if ( ch >= '0' && ch <= '9' )
  566.         ESCPRM[ESCCNT] = ESCPRM[ESCCNT] * 10 + (ch - '0');
  567.  
  568.     else if ( ch != ' ' ) {
  569.         ESCCNT++;
  570.         switch(ch) {
  571.             case 'A': AnsiA(); break;
  572.             case 'B': AnsiB(); break;
  573.             case 'C': AnsiC(); break;
  574.             case 'D': AnsiD(); break;
  575.             case 'G': AnsiG(); break;
  576.             case 'H': AnsiH(); break;
  577.             case 'J': AnsiJ(); break;
  578.             case 'K': AnsiK(); break;
  579.             case 'L': AnsiL(); break;
  580.             case 'M': AnsiM(); break;
  581.             case 'P': AnsiP(); break;
  582.  
  583.             case 'd': Ansid(); break;
  584.             case 'f': AnsiH(); break;
  585.             case 'g': Ansig(); break;
  586.             case 'm': Ansim(); break;
  587.         case 'n': Ansin(); break;
  588.         case 'p': AnsKeyAs(); break;
  589.             case 's': Ansis(); break;
  590.             case 'u': Ansiu(); break;
  591.         case 'v': Ansiv(); break;
  592.             case '@': AnsiIc(); break;
  593.         case '\"': NextChr(AnsStr); break;
  594.  
  595.             default:  Put_Ank(ch); break;
  596.         }
  597.         return;
  598.     }
  599.     NextChr(AnsiCom);
  600. }
  601. static void    AnsiEqu(ch)
  602. {
  603.     if ( ch >= '0' && ch <= '9' ) {
  604.         ESCPRM[0] = ESCPRM[0] * 10 + (ch - '0');
  605.     NextChr(AnsiEqu);
  606.  
  607.     } else if ( ch == ' ' ) {
  608.     NextChr(AnsiEqu);
  609.  
  610.     } else if ( ch == 'h' ) {
  611.     switch(ESCPRM[0]) {
  612.     case 0: case 1:
  613.     case 2: case 3:
  614.         PutCLS();
  615.         break;
  616.     case 7:
  617.         ODR_FLG = TRUE;
  618.         break;
  619.     }
  620.  
  621.     } else if ( ch == 'l' ) {
  622.     switch(ESCPRM[0]) {
  623.     case 7:
  624.         ODR_FLG = FALSE;
  625.         break;
  626.     }
  627.     } else
  628.     Put_Ank(ch);
  629. }
  630. static void    AnsiChk(ch)
  631. {
  632.     switch(ch) {
  633.     case '=':
  634.     case '?':
  635.     NextChr(AnsiEqu);
  636.     break;
  637.     case ' ':
  638.     NextChr(AnsiChk);
  639.     break;
  640.     default:
  641.     AnsiCom(ch);
  642.     break;
  643.     }
  644. }
  645. static void    AnsiESC()
  646. {
  647.     memset(ESCPRM,0,ESPSIZ);
  648.     ESCCNT = 0;
  649.     NextChr(AnsiChk);
  650. }
  651. static void    EscCom(ch)
  652. int     ch;
  653. {
  654.     switch(ch) {
  655.         case '1': TabSet(); break;
  656.         case '2': TabReSet(); break;
  657.         case '3': TabClr(); break;
  658.         case 'C': KANMOD = FALSE; break;
  659.         case 'E': InsLin(); break;
  660.         case 'G': NextChr(SVidAt); break;
  661.         case 'H': TabSet(); break;
  662.         case 'K': KANMOD = TRUE; break;
  663.         case 'R': DelLin(); break;
  664.         case 'T': EraLin(); break;
  665.         case 'Y': EraScr(); break;
  666.         case '*': PutCLS(); break;
  667.         case '=': NextChr(SCurPs); break;
  668.     case '.': NextChr(CurAtt); break;
  669.         case '[': AnsiESC(); break;
  670.         case '$': NextChr(KanjiIn); break;
  671.         case '(': NextChr(KanjiOut); break;
  672.     case '?': CurPos(); break;
  673.         default: Put_Ank(ch); break;
  674.     }
  675. }
  676. static void    cSetDC2()
  677. {
  678.     NextChr(SetDC2);
  679. }
  680. static void    cSetDC3()
  681. {
  682.     NextChr(SetDC3);
  683. }
  684. static void    cEscCom()
  685. {
  686.     NextChr(EscCom);
  687. }
  688. void    Chr_out(ch)
  689. int     ch;
  690. {
  691.     static void (*sub[])()={
  692.         NULL,   NULL,   NULL,   NULL,
  693.         NULL,   NULL,   NULL,   Beep,
  694.         PutBS,  PutTAB, PutLF,  PutHOME,
  695.         PutCLS, PutCR,  NULL,   NULL,
  696.         NULL,   NULL,   cSetDC2,cSetDC3,
  697.         NULL,   PutCLS, PutCLS, NULL,
  698.         NULL,   NULL,   NULL,   cEscCom,
  699.         CurRit, CurLft, CurUp,  CurDwn
  700.     };
  701.  
  702.     ch &= 0xFF;
  703.  
  704.     if ( EXTFLG != FALSE ) {
  705.     EXTFLG = FALSE;
  706.     (*EXTPRO)(ch);
  707.         return;
  708.     }
  709.  
  710.     if ( KANCOD != 0 ) {
  711.         if ( iskanji2(ch) ) {
  712.             Put_Kan((KANCOD << 8) | ch);
  713.             KANCOD = 0;
  714.             return;
  715.         }
  716.         Put_Ank(KANCOD);
  717.         KANCOD = 0;
  718.     }
  719.  
  720.     if ( ch < 0x20 && sub[ch] != NULL && (Con_mode & 0x80) != 0 ) {
  721.         (*sub[ch])();
  722.  
  723.     } else {
  724.         if ( KANMOD != FALSE && iskanji(ch) )
  725.             KANCOD = ch;
  726.         else if ( ch != '\0' )
  727.             Put_Ank(ch);
  728.     }
  729. }
  730. void    Con_init()
  731. {
  732.     int     i;
  733.  
  734.     memset(TABMAP,0,MAX_X/8);
  735.     for ( i = 0 ; i < SCR_X ; i += TAB )
  736.         TABMAP[ i / 8] |= BITMAP[ i % 8];
  737.     TABFLG = TRUE;
  738. }
  739.